home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / 3DTOSHI2.ZIP / mpgfx / source / gfxsound.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-22  |  4.8 KB  |  175 lines
  1.  
  2. // gfxsound.cpp
  3. //
  4. // Copyright (c) 1996 by Toshiaki Tsuji, all rights reserved.
  5.  
  6. #include "stdgfx.h"
  7. #include "gfxsound.h"
  8.  
  9. SOUND Sound;
  10.  
  11. SOUND::SOUND ()
  12.   {
  13.   } // End of Constructor for SOUND
  14.  
  15. SOUND::~SOUND ()
  16.   {
  17.   } // End of Destructor for SOUND
  18.  
  19. VOID SOUND::ReverseWORD ( SHORT *Word )
  20.   {
  21.     BYTE Hi,Lo;
  22.     Hi = (BYTE)((*Word)>>8);
  23.     Lo = (BYTE)((*Word)&0xFF);
  24.     *Word = Lo;
  25.     (*Word) <<= 8;
  26.     *Word = Hi;
  27.   } // End of ReverseWORD for SOUND
  28.  
  29. VOID SOUND::ReverseDWORD ( DWORD *DWord )
  30.   {
  31.          SHORT Hi,Lo;
  32.          Hi = (SHORT)((*DWord)>>16);
  33.          Lo = (SHORT)((*DWord)&0xFFFF);
  34.          ReverseWORD ( &Hi );
  35.          ReverseWORD ( &Lo );
  36.          *DWord = Lo;
  37.          (*DWord) <<= 16;
  38.          *DWord = Hi;
  39.   } // End of ReverseDWORD for SOUND
  40.  
  41. BOOLEAN SOUND::ReadMIDIChunk ( FILEHANDLE f, MIDICHUNK *Chunk )
  42.   {
  43.          if (File.Read ( f, Chunk, sizeof ( MIDICHUNK ) )==FAILURE)
  44.                 return FAILURE;
  45.          ReverseDWORD ( (DWORD*)&(Chunk->Length ) );
  46.  
  47.          return TRUE;
  48.   } // End of ReadMIDIChunk for SOUND
  49.  
  50. BOOLEAN SOUND::ReadMIDIHeader ( FILEHANDLE f, MIDIHEADER *Header )
  51.   {
  52.          if (ReadMIDIChunk ( f, &(Header->Chunk) )==FAILURE)
  53.                 return FAILURE;
  54.  
  55.          if (strncmp ( Header->Chunk.Name, "MThd", 4 )!=0)
  56.                 return FAILURE;
  57.  
  58.          // Get MIDI File Type
  59.          SHORT Type;
  60.          File.Read ( f, &Type, sizeof (SHORT ) );
  61.          ReverseWORD ( &Type );
  62.          Header->Type = Type;
  63.  
  64.          // Get number of Tracks
  65.          SHORT NumTracks;
  66.          File.Read ( f, &NumTracks, sizeof (SHORT ) );
  67.          ReverseWORD ( &NumTracks );
  68.          Header->NumTracks = NumTracks;
  69.  
  70.          SHORT Time;
  71.          File.Read ( f, &Time, sizeof (SHORT ) );
  72.          ReverseWORD ( &Time );
  73.          Header->Time = Time;
  74.  
  75.          return TRUE;
  76.   } // End of ReadMIDIHeader for SOUND
  77.  
  78. BOOLEAN SOUND::ReadMIDITrack ( FILEHANDLE f, MIDITRACK *Track )
  79.   {
  80.          if (ReadMIDIChunk ( f, &(Track->Chunk) )==FAILURE)
  81.                 return FAILURE;
  82.  
  83.          if (strncmp ( Track->Chunk.Name, "MTrk", 4 )!=0)
  84.                 return FAILURE;
  85.  
  86.          if (File.Read ( f, &(Track->NumEvents), sizeof(SHORT) )==FAILURE)
  87.                 return FAILURE;
  88.          ReverseWORD ( &(Track->NumEvents) );
  89.  
  90.          LONG i;
  91.          Track->Events = new MIDIEVENTTYPE [Track->NumEvents];
  92.          if (Track->Events==NULL)
  93.                 return FAILURE;
  94.  
  95.          for (i=0;i<Track->NumEvents;i++)
  96.                 {
  97.                   if (ReadMIDIEvent ( f, &(Track->Events[i]) )==FAILURE)
  98.           return FAILURE;
  99.                 } // End for
  100.          return TRUE;
  101.   } // End of ReadMIDITrack for SOUND
  102.  
  103. BOOLEAN SOUND::ReadMIDIEvent ( FILEHANDLE f, MIDIEVENTTYPE *Event )
  104.   {
  105.     Event->DeltaTime = ReadMIDIDeltaTime ( f );
  106.     return TRUE;
  107.   } // End of ReadMIDIEvent for SOUND
  108.  
  109. DWORD SOUND::ReadMIDIDeltaTime ( FILEHANDLE f )
  110.   {
  111.     BYTE Byte1,Byte2,Byte3,Byte4;
  112.  
  113.     Byte1 = Byte2 = Byte3 = Byte4 = 0;
  114.  
  115.     File.Read ( f, &Byte1, sizeof(BYTE) );
  116.     if (Byte1&0x80)
  117.                 {
  118.                   File.Read ( f, &Byte2, sizeof(BYTE) );
  119.                   if (Byte2&0x80)
  120.                          {
  121.                                 File.Read ( f, &Byte3, sizeof(BYTE) );
  122.                                 if (Byte3&0x80)
  123.                                   {
  124.                                          File.Read ( f, &Byte4, sizeof(BYTE) );
  125.                                   } // End if
  126.                          } // End if
  127.                 } // End if
  128.  
  129.     DWORD Time;
  130.          Time = ((LONG)Byte1<<24)+((LONG)Byte2<<16)+((LONG)Byte3<<8)
  131.                                 +(LONG)Byte4;
  132.  
  133.          ReverseDWORD ( &Time );
  134.     return Time;
  135.   } // End of ReadMIDIDeltaTime for SOUND
  136.  
  137. BOOLEAN SOUND::LoadMIDI ( STRING FileName )
  138.   {
  139.          FILEHANDLE f;
  140.  
  141.          f = File.Open ( FileName, OPEN_READ | OPEN_BINARY );
  142.          if (f==NULL)
  143.                 return FAILURE;
  144.  
  145.          MIDIHEADER Header;
  146.  
  147.          if (ReadMIDIHeader ( f, &Header )==FAILURE)
  148.                 {
  149.                   File.Close ( f );
  150.                   return FAILURE;
  151.                 } // End if
  152.  
  153.          LONG i;
  154.          MIDITRACK *Tracks;
  155.          Tracks = new MIDITRACK [Header.NumTracks];
  156.          if (Tracks==NULL)
  157.                 {
  158.                   File.Close ( f );
  159.                   return FAILURE;
  160.                 } // End if
  161.  
  162.          for (i=0;i<Header.NumTracks;i++)
  163.                 {
  164.                   if (ReadMIDITrack ( f, &Tracks[i] )==FAILURE)
  165.                          {
  166.                                 File.Close ( f );
  167.             return FAILURE;
  168.                          } // End if
  169.                 } // End for
  170.  
  171.          File.Close ( f );
  172.          return TRUE;
  173.   } // End of LoadMIDI for SOUND
  174.  
  175.